<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script src="lodash.min.js"></script>
		<script>
			/* 克隆 */
			// 浅拷贝，可以复制原对象基本类型和引用类型的指针；cloneWith可以使用函数影响拷贝过程
			var objects = {num:1,str:'a',boolean:true,arr:[1],obj:{a:1},arrObj:[{a:1},{b:2}]};
			var shallow = _.clone(objects);
			shallow.num=shallow.arr[0]=2
			console.log(objects);
			// objects.num=> 1	objects.arr=>[2]
			
			// cloneDeepWith支持函数影响复制过程
			function customizer(value) {
			  if (_.isElement(value)) {
			    return value.cloneNode(true);
			  }
			}
			var el = _.cloneDeepWith(document.getElementsByTagName('div')[0], customizer);
			
			
			/* 可以判断对象、比较对象 */
			// 判断对象指定属性是否满足要求
			var object = { 'age': 12, 'gender': 1 };
			_.conformsTo(object, { 'age': function(n) { return n.age > 10; } });
			// => true
			
			// conformsTo的衍生，执行一个深度比较，来确定 object 是否含有和 source 完全相等的属性值，支持isMatchWith自定义比较
			var object = { 'a': 1, 'b': 2 };
			_.isMatch(object, { 'b': 2 });
			// => true
			
			// 值一样就行
			var object = { 'a': 1 };
			var other = { 'a': 1 };
			_.isEqual(object, other);
			// => true
			
			// isEqualWith支持自定义方法比较
			function isGreeting(value) {
			  return /^h(?:i|ello)$/.test(value);
			}
			function customizer(objValue, othValue) {
			  if (isGreeting(objValue) && isGreeting(othValue)) {
			    return true;
			  }
			}
			var array = ['hello', 'goodbye'];
			var other = ['hi', 'goodbye'];
			_.isEqualWith(array, other, customizer);
			// => true
			
			
			/* 可以对空的进行判断 */
			// 检查 value 是否为一个空对象，集合，映射或者set
			_.isEmpty([]);
			// => true
			_.isEmpty({});
			// => true
			console.log(_.isEmpty(new Set()));
			console.log(_.isEmpty(new Map()));
			// 检查 value 是否是 null 或者 undefined；类似的还有isNull
			_.isNil(null);
			// => true
			_.isNil(void 0);
			// => true
			// 检查 value 是否是 undefined
			_.isUndefined(void 0);
			// => true
			
			
			/* 可以对基本类型进行判断 */
			// 检查 value 是否是原始 boolean 类型或者对象
			_.isBoolean(false);
			// 检查 value 是否是原始Number
			_.isNumber(Infinity);
			// => true
			_.isNumber('3');
			// => false
			// 基于Number.isInteger，检查 value 是否为一个整数；此外还有isNaN、isFinite；
			_.isInteger(3);
			// => true
			_.isFinite(Number.MIN_VALUE);
			// => true
			// 判断有限值，存在toSafeInteger
			_.isSafeInteger(Number.MIN_VALUE);
			// => false
			// 检查 value 是否是原始字符串String或者对象，存在toString
			_.isString('abc');
			// => true
			
			
			/* 可以对引用类型判断 */
			// 检查 value 是否是 Function 对象。
			_.isFunction(_);
			// 检查 value 是否为 Object，不同于typeof，他碰到null是false，而类似的isObjectLike与typeof==object等效
			_.isObject(null);
			// => false
			// 检查 value 是否是类数组。
			console.log(_.isArrayLike({1:1,2:2,length:5}));
			// => true
			_.isArrayLike(document.body.children);
			// => true
			_.isArrayLike('abc');
			// => true
			
			// 检查 value 是否是一个原生函数。
			_.isNative(Array.prototype.push);
			// => true
			_.isNative(_);
			// => false
			
			// 检查 value 是否是普通对象。 也就是说该对象由 Object 构造函数创建
			function Foo() {
			  this.a = 1;
			}
			_.isPlainObject(new Foo);
			// => false
			_.isPlainObject([1, 2, 3]);
			// => false
			_.isPlainObject({ 'x': 0, 'y': 0 });
			// => true
			_.isPlainObject(Object.create(null));
			// => true
			
			// 可以对普通对象是哪一种进行判断
			// 检查 value 是否为RegExp对象
			_.isRegExp(/abc/);
			// => true
			// 检查 value 是否是 Error以及衍生对象
			_.isError(new Error);
			// => true
			// 检查 value 是否是个 buffer。
			// _.isBuffer(new ArrayBuffer(2));报错
			// => true
			_.isBuffer(new Uint8Array(2));
			// => false
			// 检查 value 是否是 Date 对象。
			_.isDate(new Date); 
			// => true
			// 检查 value 是否是可能是 DOM 
			_.isElement(document.body);
			// => true
			// 检查 value 是否是一个类 arguments 对象
			_.isArguments(function() { return arguments; }());
			// => true
			_.isArguments([1, 2, 3]);
			// => false
			// https://blog.csdn.net/weixin_42232156/article/details/121808096
			// 检查 value 是否是 ArrayBuffer 对象。
			_.isArrayBuffer(new ArrayBuffer(2));
			// => true
			// 检查 value 是否是一个Set对象
			_.isSet(new Set);
			// => true
			// 检查 value 是否是原始 Symbol 或者对象
			_.isSymbol(Symbol.iterator);
			// => true
			// 检查 value 是否是TypedArray
			_.isTypedArray(new Uint8Array);
			// => true
			// 检查 value 是否是 WeakMap 对象
			_.isWeakMap(new WeakMap);
			// => true
			// 检查 value 是否是 WeakSet 对象
			_.isWeakSet(new WeakSet);
			// => true
			
			// Object.values()一样
			console.log(_.toArray({ 'a': 1, 2: 'b' }));
			// 向下取整
			_.toInteger('3.2');
			// => 3
			// 和减0等效
			_.toNumber('3.2');
			// => 3.2
			
			// 转换 value 为普通对象。 包括继承的可枚举属性。
			function Foo() {
			  this.b = 2;
			}
			Foo.prototype.c = 3;
			_.assign({ 'a': 1 }, new Foo);
			// => { 'a': 1, 'b': 2 }
			_.assign({ 'a': 1 }, _.toPlainObject(new Foo));
			// => { 'a': 1, 'b': 2, 'c': 3 }
			
			
			
			/* 意义不明 */
			// 判断参数能否作为数组length
			_.isLength(3);
			// => [1, 2]
			// => true
			// 转换 value 为一个有限数字
			_.toFinite(Number.MIN_VALUE);
			// => 5e-324
			_.toFinite(Infinity);
			// => 1.7976931348623157e+308
			// 转换 value 为用作类数组对象的长度整数
			
		</script>
		<div><span></span></div>
	</body>
</html>